home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / incl / LEDA / d3_dictionary.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-05  |  3.4 KB  |  123 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  d3_dictionary.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #ifndef LEDA_d3_dictionary_H
  18. #define LEDA_d3_dictionary_H
  19.  
  20. #include <LEDA/impl/range_tree.h>
  21. typedef rt_item dic3_item;
  22.  
  23.  
  24.  
  25. template<class type1, class type2, class type3, class itype>
  26. class _CLASSTYPE d3_dictionary : public range_tree {
  27.  
  28.   // redefine the virtual functions of class range_tree
  29.  
  30.   void rt_clear_key(GenPtr*& x) const { 
  31.     Clear(ACCESS(type1,x[0])); Clear(ACCESS(type2,x[1])); 
  32.     Clear(ACCESS(type3,x[2])); 
  33.   }
  34.   
  35.   void rt_copy_key(GenPtr*& x) const { 
  36.     Copy(ACCESS(type1,x[0])); Copy(ACCESS(type2,x[1])); 
  37.     Copy(ACCESS(type3,x[2])); 
  38.   }
  39.  
  40.   void rt_print_key(int d,GenPtr*& x) const {
  41.     switch(d) {
  42.       case 0: Print(ACCESS(type1,x[0]),cout);
  43.                 break;
  44.       case 1: Print(ACCESS(type2,x[1]),cout);
  45.                 break;
  46.       case 2: Print(ACCESS(type3,x[2]),cout);
  47.                 break;
  48.     }
  49.   }
  50.  
  51.   void rt_clear_inf(GenPtr& x) const { Clear(ACCESS(itype,x));}
  52.   void rt_copy_inf(GenPtr& x) const { Copy(ACCESS(itype,x));}
  53.  
  54.   int rt_cmp(int d, GenPtr* p, GenPtr* q) const { 
  55.     switch(d) {
  56.       case 0: return compare(ACCESS(type1,p[0]),ACCESS(type1,q[0]));
  57.       case 1: return compare(ACCESS(type2,p[1]),ACCESS(type2,q[1]));
  58.       case 2: return compare(ACCESS(type3,p[2]),ACCESS(type3,q[2]));
  59.     }
  60.   }
  61.  
  62.   range_tree* new_range_tree(int dim, int lev) { 
  63.     return new d3_dictionary<type1,type2,type3,itype>(lev); 
  64.   }
  65.  
  66.   public:
  67.   
  68.     d3_dictionary( int lev=0 ) : range_tree(3,lev) {}
  69.     ~d3_dictionary() { clear(); }
  70.   
  71.     itype inf(dic3_item x)    { return ACCESS(itype,x->inf()); }
  72.     type1 key1(dic3_item x)   { return ACCESS(type1,x->key(0)); }
  73.     type2 key2(dic3_item x)   { return ACCESS(type2,x->key(1)); }
  74.     type3 key3(dic3_item x)   { return ACCESS(type3,x->key(2)); }
  75.   
  76.   
  77.     void  change_inf(dic3_item x, itype i) { 
  78.       Clear(ACCESS(itype,x->inf())); 
  79.       x->inf() = Copy(i); 
  80.     }
  81.   
  82.     dic3_item min_key1() { return range_tree::rt_min(0); }
  83.     dic3_item max_key1() { return range_tree::rt_max(0); }
  84.     dic3_item min_key2() { return range_tree::rt_min(1); }
  85.     dic3_item max_key2() { return range_tree::rt_max(1); }
  86.     dic3_item min_key3() { return range_tree::rt_min(2); }
  87.     dic3_item max_key3() { return range_tree::rt_max(2); }
  88.   
  89.     dic3_item insert(type1 x,type2 y,type3 z,itype i)
  90.     { 
  91.       rt_item p = new rt_elem(Copy(x),Copy(y),Copy(z),Copy(i));
  92.       return range_tree::insert(p);
  93.      }
  94.     
  95.     list<rt_item> range_search( type1 x0, type1 x1,
  96.                       type2 y0, type2 y1,
  97.                       type3 z0, type3 z1 )
  98.     { 
  99.       rt_elem p(Convert(x0),Convert(y0),Convert(z0),0);
  100.       rt_elem q(Convert(x1),Convert(y1),Convert(z1),0);
  101.       return range_tree::query(&p,&q);
  102.     }
  103.   
  104.     dic3_item lookup( type1 x, type2 y, type3 z ) { 
  105.       rt_elem p(Convert(x),Convert(y),Convert(z),0);
  106.       return range_tree::lookup(&p);
  107.     }
  108.   
  109.     void del(type1 x,type2 y, type3 z) { 
  110.       rt_elem p(Convert(x),Convert(y),Convert(z),0);
  111.       range_tree::del(&p);
  112.      }
  113.   
  114.     void del_item(dic3_item it) { range_tree::del(it); }
  115.     list<dic3_item> all_items() { return range_tree::all_items(); }
  116. };
  117.  
  118. // iteration macro
  119. //
  120. #define forall_dic3_items(x,T)  (T).init_iteration(); forall(x,(T).L )
  121.  
  122. #endif
  123.